package com.will.weiyuekotlin

import android.widget.TextView
import org.junit.Assert.assertEquals
import org.junit.Test

/**
 * Example local unit test, which will execute on the development machine (host).
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
class ExampleUnitTest {
    @Test
    fun addition_isCorrect() {
        assertEquals(4, 2 + 2)
    }


    open class a {
        fun a() {}
        open fun b() {}

    }

    abstract class b : a() {
        override abstract fun b()
    }


    class ot {
        val a = 2

        inner class inb {
            fun a() = a
            fun a2(): Int {
                return a
            }

            fun d() {
                var o = this@ot
                println("内部类可以引用外部类的成员，例如：" + o.a)
            }
        }
    }

    class Outer {
        private val bar: Int = 1
        var v = "成员属性"

        /**嵌套内部类**/
        inner class Inner {
            fun foo() = bar  // 访问外部类成员
            fun innerTest() {
                var o = this@Outer //获取外部类的成员变量
                println("内部类可以引用外部类的成员，例如：" + o.v)
            }
        }
    }

    class Tests {
        var v = "成员属性"

        fun setInterFace(test: TestInterFace) {
            test.test()
        }
    }

    /**
     * 定义接口
     */
    interface TestInterFace {
        fun test()
    }

    fun main(args: Array<String>) {
        var test = Tests()

        /**
         * 采用对象表达式来创建接口对象，即匿名内部类的实例。
         */
        test.setInterFace(object : TestInterFace {
            override fun test() {
                println("对象表达式创建匿名内部类的实例")
            }
        })
        test.setInterFace(object : TestInterFace {
            override fun test() {
                TODO("not implemented") //To change body of created functions use File | Settings | File Templates.
            }

        })
    }

    open class Person(var name: String, var age: Int) {// 基类

    }

    class Student(name: String, age: Int, var no: String, var score: Int) : Person(name = name, age = age) {

    }

    // 测试
    fun main2(args: Array<String>) {
        val s = Student("Runoob", 18, "S12346", 89)
        println("学生名： ${s.name}")
        println("年龄： ${s.age}")
        println("学生号： ${s.no}")
        println("成绩： ${s.score}")
    }


    /**用户基类**/
    open class Person3 {
        open fun study() {       // 允许子类重写
            println("我毕业了")
        }
    }

    /**子类继承 Person 类**/
    class Student3 : Person3() {
        override fun study() {    // 重写方法
            println("我在读大学")
        }

    }

    fun main3(args: Array<String>) {
        val s = Student3()
        s.study();

    }


    open class A {
        open val field: String = "asd"
        open fun f() {
            print("A")
        }

        fun a() {
            print("a")
        }
    }

    interface B {
        fun f() {
            print("B")
        } //接口的成员变量默认是 open 的

        fun b() {
            print("b")
        }
    }

    class C : A(), B {
        override var field: String = "asda"
        var ss: String = ""
            get() = field + "111"
            set(value) {
                field = value + "222"
            }

        override fun f() {
            super<A>.f()//调用 A.f()
            super<B>.f()//调用 B.f()
        }
    }

    fun main4(args: Array<String>) {
        val c = C()
        c.f();

    }


    interface MyInterface {
        var name: String //name 属性, 抽象的
    }

    class MyImpl : MyInterface {
        override var name: String = "runoob" //重写属性
    }


    class User(var name: String)

    /**扩展函数**/
    fun User.Print() {
        print("用户名 $name")
    }

    fun main5(arg: Array<String>) {
        var user = User("Runoob")
        user.Print()


    }


    // 扩展函数 swap,调换不同位置的值
    fun MutableList<Int>.swap(index1: Int, index2: Int) {
        val tmp = this[index1]     //  this 对应该列表
        this[index1] = this[index2]
        this[index2] = tmp
    }

    fun main6(args: Array<String>) {

        val l = mutableListOf(1, 2, 3)
        // 位置 0 和 2 的值做了互换
        l.swap(0, 2) // 'swap()' 函数内的 'this' 将指向 'l' 的值

        println(l.toString())
    }


    /*扩展空对象*/
    fun Any?.toString(): String {
        if (this == null) return "null"
        // 空检测之后，“this”会自动转换为非空类型，所以下面的 toString()
        // 解析为 Any 类的成员函数
        return toString()
    }

    fun main7(arg: Array<String>) {
        var t = null
        println(t.toString())
    }

    /*扩展属性*/
    val <T> List<T>.lastIndex: Int
        get() = size - 1

    fun main8(arg: Array<String>) {
        var lis = listOf(2, 3, 4)
        print(lis.lastIndex)
    }






    class NumberTest {
        companion object {

            const val m = 2 //常量

            @JvmField
            val n = 3 //常量

            @JvmField
            var flag = false

            @JvmStatic
            fun plus(num1: Int, num2: Int): Int {
                return num1 + num2
            }
        }
    }
    fun main9(arg: Array<String>) {

        print(NumberTest.flag)
        print(NumberTest.plus(1,2))
        print(NumberTest.m)
    }

}
